const { posts, Post } = require('../models/Post');
const { generateId } = require('../utils');
const { validateNumber, validateRequiredFields } = require('../utils');
const { dbConfig } = require('../config/database');

// 获取所有文章
const getAllPosts = async (req, res) => {
  try {
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const dbPosts = await Post.find({}).populate('categoryId');
        res.status(200).json(dbPosts);
      } catch (dbError) {
        console.error('数据库查询失败:', dbError);
        // 降级到内存数据
        res.status(200).json(posts);
      }
    } else {
      // 使用内存数据模式
      res.status(200).json(posts);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '获取文章列表失败',
      message: error.message 
    });
  }
};

// 根据ID获取文章
const getPostById = async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '文章ID必须是数字' 
      });
    }
    
    const postId = parseInt(id);
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const post = await Post.findById(postId).populate('categoryId');
        if (!post) {
          return res.status(404).json({ 
            error: '文章未找到',
            message: `ID为${postId}的文章不存在`
          });
        }
        res.status(200).json(post);
      } catch (dbError) {
        console.error('数据库查询失败:', dbError);
        // 降级到内存数据
        const post = posts.find(p => p.id === postId);
        if (!post) {
          return res.status(404).json({ 
            error: '文章未找到',
            message: `ID为${postId}的文章不存在`
          });
        }
        res.status(200).json(post);
      }
    } else {
      // 使用内存数据模式
      const post = posts.find(p => p.id === postId);
      if (!post) {
        return res.status(404).json({ 
          error: '文章未找到',
          message: `ID为${postId}的文章不存在`
        });
      }
      res.status(200).json(post);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '获取文章信息失败',
      message: error.message 
    });
  }
};

// 创建新文章
const createPost = async (req, res) => {
  try {
    const { title, content, author, categoryId } = req.body;
    
    // 验证必填字段
    const validation = validateRequiredFields({ title, content, author }, ['title', 'content', 'author']);
    if (!validation.isValid) {
      return res.status(400).json({ 
        error: '字段验证失败', 
        message: validation.errors.join(', ') 
      });
    }
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const newPost = new Post({ 
          title, 
          content, 
          author, 
          categoryId: categoryId || null,
          createdAt: new Date(),
          updatedAt: new Date()
        });
        
        const savedPost = await newPost.save();
        res.status(201).json(savedPost);
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const newPost = new Post(
          generateId(posts),
          title,
          content,
          author,
          categoryId ? parseInt(categoryId) : null
        );
        posts.push(newPost);
        res.status(201).json(newPost);
      }
    } else {
      // 使用内存数据模式
      const newPost = new Post(
        generateId(posts),
        title,
        content,
        author,
        categoryId ? parseInt(categoryId) : null
      );
      posts.push(newPost);
      res.status(201).json(newPost);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '创建文章失败',
      message: error.message 
    });
  }
};

// 更新文章
const updatePost = async (req, res) => {
  try {
    const { id } = req.params;
    const { title, content, author, categoryId } = req.body;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '文章ID必须是数字' 
      });
    }
    
    const postId = parseInt(id);
    
    // 验证必填字段
    const validation = validateRequiredFields({ title, content, author }, ['title', 'content', 'author']);
    if (!validation.isValid) {
      return res.status(400).json({ 
        error: '字段验证失败', 
        message: validation.errors.join(', ') 
      });
    }
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const post = await Post.findByIdAndUpdate(
          postId,
          { 
            title, 
            content, 
            author, 
            categoryId: categoryId || null,
            updatedAt: new Date()
          },
          { new: true, runValidators: true }
        ).populate('categoryId');
        
        if (!post) {
          return res.status(404).json({ 
            error: '文章未找到',
            message: `ID为${postId}的文章不存在`
          });
        }
        
        res.status(200).json(post);
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const postIndex = posts.findIndex(p => p.id === postId);
        if (postIndex === -1) {
          return res.status(404).json({ 
            error: '文章未找到',
            message: `ID为${postId}的文章不存在`
          });
        }
        
        posts[postIndex].update(
          title,
          content,
          categoryId ? parseInt(categoryId) : null
        );
        res.status(200).json(posts[postIndex]);
      }
    } else {
      // 使用内存数据模式
      const postIndex = posts.findIndex(p => p.id === postId);
      if (postIndex === -1) {
        return res.status(404).json({ 
          error: '文章未找到',
          message: `ID为${postId}的文章不存在`
        });
      }
      
      posts[postIndex].update(
        title,
        content,
        categoryId ? parseInt(categoryId) : null
      );
      res.status(200).json(posts[postIndex]);
    }
  } catch (error) {
    res.status(500).json({ 
      error: '更新文章失败',
      message: error.message 
    });
  }
};

// 删除文章
const deletePost = async (req, res) => {
  try {
    const { id } = req.params;
    
    if (!validateNumber(id)) {
      return res.status(400).json({ 
        error: '参数错误', 
        message: '文章ID必须是数字' 
      });
    }
    
    const postId = parseInt(id);
    
    // 检查是否使用数据库
    if (!dbConfig.useInMemory) {
      // 使用数据库模式
      try {
        const post = await Post.findByIdAndDelete(postId);
        if (!post) {
          return res.status(404).json({ 
            error: '文章未找到',
            message: `ID为${postId}的文章不存在`
          });
        }
        
        res.status(200).json({ message: '文章删除成功' });
      } catch (dbError) {
        console.error('数据库操作失败:', dbError);
        // 降级到内存数据
        const postIndex = posts.findIndex(p => p.id === postId);
        if (postIndex === -1) {
          return res.status(404).json({ 
            error: '文章未找到',
            message: `ID为${postId}的文章不存在`
          });
        }
        
        posts.splice(postIndex, 1);
        res.status(200).json({ message: '文章删除成功' });
      }
    } else {
      // 使用内存数据模式
      const postIndex = posts.findIndex(p => p.id === postId);
      if (postIndex === -1) {
        return res.status(404).json({ 
          error: '文章未找到',
          message: `ID为${postId}的文章不存在`
        });
      }
      
      posts.splice(postIndex, 1);
      res.status(200).json({ message: '文章删除成功' });
    }
  } catch (error) {
    res.status(500).json({ 
      error: '删除文章失败',
      message: error.message 
    });
  }
};

module.exports = {
  getAllPosts,
  getPostById,
  createPost,
  updatePost,
  deletePost
};